En el post anterior, vimos como instalar Rust y para qué nos podría servir Cargo, también creamos un pequeño "hello world" sin y con Cargo, sin embargo, hay muchas funcionalidades de Cargo de las cuales no hemos platicado todavía, en esta publicación vamos a cubrir aún más funcionalidades.

Anteriormente hemos creado un proyecto llamado hello-cargo

Para crearlo, dentro de una carpeta de nuestra preferencia ejecutamos el comando:

cargo new hello-cargo

y en el archivo src/main.rs, colocamos el siguiente código:

        
        
            // src/main.rs

fn main() {
  println!("Hello World!");
}
        
        
    

Luego lo compilamos utilizando el comando:

cargo build

Habíamos hablado que el compilado del comando anterior, no era conveniente distribuirlo, ahora vamos a aprender a crear una versión que SI podamos distribuir.

Versión Para Distribución.

Para crear una versión ejecutable para distribución, siempre desde la carpeta del proyecto hello-cargo (sin meterse al src), ejecuta el siguiente comando:

cargo build --release

Recuerda que los archivos ejecutables, cargo los coloca dentro de la carpeta /target.

Verás que esta vez, el ejecutable lo ha colocado dentro de la carpeta

hello-cargo/target/release/hello-cargo

Esta versión ha sido optimizado para ambientes de producción o para distribuirlo.

Consideraciones de un build.

el comando cargo build o cargo build --release, sirven para crear versiones ejecutables y para distribución. Nuestro ejemplo, es un programa bastante pequeño y únicamente muestra un digno "Hello World!" en la terminal, pero a medida nuestros programas son más complejos y requieren paquetes o crates externos, el tiempo de compilación puede tardar muchísimo tiempo.

Si solamente te gustaría probar si tu código es válido, sin necesidad de esperar tanto tiempo para que tu programa compile, cargo te ofrece el siguiente comando.

cargo check

El comando anterior verificará que tu programa se encuentre sin errores de sintaxis o de otros tipos sin necesidad de compilar todo el programa, es bastante útil cuando solo quieres verificar tu código, es muchísimo más rápido que hacer un build completo.

Cargo como gestor de paquetes.

Cargo también nos ayuda a gestionar paquetes, por ejemplo si vienes de un background de python te sonarán los paquetes que se instalan con pip, paquetes como los que instala npm o yarn si vienes de javascript o maven si vienes de Java.

También a lo mejor has escuchado del package.json o del requirements.txt en python, Rust también tiene un archivo para ello y este es el archivo llamado Cargo.toml bajo la sección [dependencies], por ejemplo para nuestro ejemplo hello-cargo verás que no tenemos ninguna dependencia instalada.

        
        
            // Cargo.toml

[package]
name = "hello-cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

        
        
    

Utilizando nuestro primer crate.

En Rust, a los paquetes o a las librerías, les llamamos crates, para este ejemplo vamos a utilizar nuestro primer crate. Un crate no es más que una librería ya creada por alguien que generosamente lo pone a disposición de la comunidad y que nos ayuda a resolver un problema. En futuras publicaciones vamos a aprender a crear nuestros propios crates o cómo los compartiremos con la comunidad.

Regresando a nuestro ejemplo, vamos a crear otro programa simple que le pasaremos un String en la línea de comando y el programa codificará la string a base64 y lo mostrará en pantalla.

Para este ejemplo vamos a utilizar un crate externo para codificar el String a base64.

Empecemos creando un nuevo proyecto, para ello en la carpeta de tu preferencia (en mi caso /proyectos) crearemos el proyecto con:

cargo new ejemplo-uso-crates

Ahora abriremos la carpeta ejemplo-uso-crates, dentro de nuestro IDE o editor de texto favorito y vamos a ver la estructura que ya nos hemos acostumbrado:

Vamos a empezar borrando el contenido en src/main.rs y reemplazarlo por el siguiente código.

        
        
            // src/main.rs

use std::env;

fn main() {
    let args: Vec<String> = env::args().collect();

    let parametro = &args[1];

    println!("Parametro {}", parametro);
}

        
        
    

Por simplicidad, no vamos a realizar ninguna validación para nuestro ejemplo, en programas profesionales, sin embargo, sí te recomiendo validar tu código, pero por el momento solamente queremos enfocarnos en aprender a incluir los crates externos.

Vamos a explorar el código un poco.

La línea:

use std::env;

le indica a Rust que queremos usar (use, similar a import) el módulo std::env, en cual ya viene integrado con nuestra instalación de Rust, con ello vamos a tener acceso a todas las funciones que el módulo provee, dentro de estas funciones, vamos a encontrar en la siguiente línea la primera de ellas:

let args: Vec<String> = env::args().collect();

la línea anterior se encarga de tomar el input que hacemos en nuestro terminal y guardará cada palabra dentro de un Vector (similar a los arrays de otros lenguajes) de Strings, en Rust es importantísimo definir los tipos de datos, aunque también puede deducir muchos de ellos.

la línea:

let parametro = &args[1];

le dice a Rust que guarde el argumento en la posición 1 del array de parámetros dentro de una variable llamada parámetro. Los vectores en Rust empiezan en el indice 0, que estarí reservado para el nombre de nuestro ejecutable, por lo tanto el siguiente parámetro, es decir el 1, contiene el String que vamos a codificar a base 4.

Por último, la línea:

println!("Parametro {}", parametro);

Muestra en pantalla el valor del parámetro.

Ahora nuestro programa lo podemos ejecutar de dos formas, la primera es creando un build. En la carpeta del proyecto (sin entrar a src) ejecuta el comando:

cargo build

cuando finalice, podrás ejecutar el siguiente comando desde el root de tu proyecto.

target/debug/ejemplo-uso-crates prueba

Si todo ha salido bien en tu terminal debes ver el siguiente mensaje:

Parametro prueba

La segunda manera es ejecutarlo con cargo

cargo run prueba

Si todo sale bien, deberías de ver el mismo mensaje anterior "Parametro prueba" en tu terminal.

Agregando un crate.

Ahora que ya sabemos leer un parámetro desde la terminal, vamos a codificarlo a base64, para ello modifiquemos un poco el src/main.rs

        
        
            // src/main.rs

use std::env;
use base64::encode;

fn main() {
    let args: Vec<String> = env::args().collect();

    let parametro = &args[1];

    println!("Parametro {}", parametro);

    let parametro_base64 = encode(&parametro);
    println!("Parametro {} - Base64: {}", parametro, parametro_base64);
}

        
        
    

Si ahora ejecutamos nuestro programa:

cargo run prueba

Vamos a observar que el compilador de Rust nos muestra el siguiente error:

El error anterior indica que Rust no puede encontrar el crate o módulo base64, porque Rust no viene con ese módulo instalado por defecto, por lo que tenemos que hacerle saber que lo descargue y nos permita utilizarlo. Para ello debemos agregarlo en el archivo Cargo.toml

Bajo la sección de [dependencies] debes agregar base64 = "0.13.0", el cual indica que vamos a instalar la version 0.13.0 de un crate llamado base64, el cual tiene todas las funciones necesarias para codificar (o decodificar) un String a base64

Tu Cargo.toml debe verse como el siguiente:

        
        
            [package]
name = "ejemplo-uso-crates"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
base64 = "0.13.0"

        
        
    

Ahora vamos a ejecutar nuevamente el programa y veremos que ahora el programa si funcionara:

cargo run prueba

Vemos que ahora si en la ultima linea de la imagen nos muestra el parámetro y la version codificada en base64 del String "prueba"

Pero quiero que también observes la primera linea que dice "Updating crates.io index", esta línea indica que Cargo ha descargado todas las dependencias en el archivo Cargo.toml y ahora si la podemos utilizar.

Ahora una pregunta importante de responder es ¿de dónde descarga cargo los módulos o crates?

Crates.io

Cargo descarga los crates directamente de un sitio llamado crates.io

En este sitio web podrás encontrar todos los crates que puedas imaginarte y para muchos usos, por ejemplo si buscamos el crate que acabos de utilizar base64, veremos que lo encontraremos dentro del listado.

En la imagen podemos ver tanto la última version, como todas las descargas a la fecha y hace cuanto tiempo fue su última actualización, si le damos click y vemos más detalles, vamos a observar algunos ejemplos de cómo utilizarlo.

Si vemos a la derecha de la imagen, podremos notar que hay una opción de Install, que si te fijas, es la misma que hemos colocado en el archivo Cargo.toml.

También en la sección que dice "Documentation" vamos a encontrar un enlace a la documentación detallada del crate y por debajo un enlace al repositorio en github.

En la siguiente y última parte (y también la más cortita jejejeje), vamos a hablar sobre Cargo Edit, un módulo super bueno para Rust, si este Post te ha sido de utilidad comparte con tus amigos y en tus redes sociales.

Puedes encontrar el código fuente de nuestro ejemplo dando click a este enlace.

println!("Hasta la próxima");